// 首页逻辑
const { isAdmin, getCurrentRole, getCurrentUser } = require('../../../utils/auth')
const { searchNotices, getNotices } = require('../../../api/notice')
const { searchServiceItems } = require('../../../api/serviceItems')
const { getMyApplications } = require('../../../api/minLivingAllowance')
const { getActiveActivities } = require('../../../api/activities')
const smartLoadingManager = require('../../../utils/smartLoadingManager')

Page({
  data: {
    // 全局加载状态
    globalLoading: false,
    globalSkeletonType: 'default',
    globalLoadingText: '加载中...',
    
    // 紧急通知列表（支持轮播）- 从API数据中动态获取
    urgentNotices: [],
    currentUrgentIndex: 0, // 当前显示的紧急通知索引
    searchQuery: '',
    // 活动轮播图：乡村特色活动推广
    banners: [],
    // 高频入口：emoji + 主题色背景
    shortcuts: [
      { key: 'service', text: '事项办理', icon: '/assets/icons/daibanshixiang.png', theme: 'blue' },
      { key: 'progress', text: '办事进度', icon: '/assets/icons/banshijindu.png', theme: 'purple' },
      { key: 'open', text: '村务公告', icon: '/assets/icons/caiwu.png', theme: 'orange' },
      { key: 'complain', text: '投诉建议', icon: '/assets/icons/tousujianyi.png', theme: 'green' }
    ],
    servicesPreview: [
      { id: 'hukou', name: '户籍办理', desc: '户口迁入/迁出' },
      { id: 'dibao', name: '低保申请', desc: '低收入保障' },
      { id: 'yanglao', name: '养老补贴', desc: '老年补贴申请' },
      { id: 'zhuzhai', name: '宅基地', desc: '宅基地审批' }
    ],
    notices: [
      { id: 'n1', title: '关于台风预警通知，做好防范准备', time: '09-28' },
      { id: 'n2', title: '村务公开：9月财务收支情况', time: '09-27' },
      { id: 'n3', title: '国庆假期垃圾分类与值班安排', time: '09-25' }
    ],
    // 新增：我的办件进度
    progressList: [
      { id: 'app001', title: '最低生活保障申请', statusTag: 'pending', statusText: '待审核', updateTime: '01-18 14:20' },
      { id: 'app002', title: '宅基地申请', statusTag: 'pending', statusText: '待审核', updateTime: '01-20 09:15' },
      { id: 'app003', title: '残疾人两项补贴', statusTag: 'done', statusText: '已完成', updateTime: '01-16 16:30' }
    ],
    loading: false
  },

  onLoad() {
    // 显示页面加载效果
    smartLoadingManager.onPageEnter('pages/common/index/index')
    
    // 检查用户是否已登录
    this.checkLoginStatus()
    // 加载最新公告数据
    this.loadLatestNotices()
    // 加载用户申请进度数据
    this.loadUserProgress()
    // 加载活动轮播图数据
    this.loadActiveActivities()
    // 测试背景色稳定性
    this.testBackgroundColorStability()
  },

  onShow() {
    // 每次显示页面时检查登录状态
    this.checkLoginStatus()
    // 重新加载用户申请进度数据
    this.loadUserProgress()
    // 重新加载活动轮播图数据
    this.loadActiveActivities()
  },

  onReady() {
    // 页面准备完成，隐藏加载效果
    smartLoadingManager.onPageDataLoaded('pages/common/index/index')
  },

  // 更新全局加载状态
  updateGlobalLoading(data) {
    this.setData({
      globalLoading: data.globalLoading,
      globalSkeletonType: data.globalSkeletonType || 'default',
      globalLoadingText: data.globalLoadingText || '加载中...'
    })
  },

  onUnload() {
    // 页面卸载时清理定时器
    if (this.searchTimer) {
      clearTimeout(this.searchTimer)
      this.searchTimer = null
    }
  },

  // 检查登录状态
  checkLoginStatus() {
    try {
      const role = getCurrentRole()
      console.log('首页检查登录状态，当前角色:', role)
      if (!role) {
        console.log('未登录，跳转到登录页面')
        // 未登录，跳转到登录页面
        wx.redirectTo({ url: '/pages/auth/login/index' })
        return
      }
      console.log('已登录，显示页面内容')
      // 已登录，可以正常显示页面内容
    } catch (e) {
      console.error('获取角色失败:', e)
      // 获取角色失败，跳转到登录页面
      wx.redirectTo({ url: '/pages/auth/login/index' })
    }
  },

  // 加载最新公告数据
  async loadLatestNotices(forceRefresh = false) {
    try {
      console.log('开始加载最新公告数据', forceRefresh ? '(强制刷新)' : '')
      
      // 调用API获取最新公告
      const noticesParams = {
        page: 1,
        limit: 10, // 获取10条数据，然后取前3条
        status: 'published', // 只获取已发布的公告
        sortBy: 'publish_time',
        sortOrder: 'desc'
      }
      
      // 如果是强制刷新，添加额外的时间戳参数
      if (forceRefresh) {
        noticesParams._refresh = Date.now()
      }
      
      const noticesResponse = await getNotices(noticesParams)
      
      console.log('获取公告API响应:', noticesResponse)
      console.log('API响应详情:', {
        success: noticesResponse?.success,
        hasData: !!noticesResponse?.data,
        hasNotices: !!noticesResponse?.data?.notices,
        noticesCount: noticesResponse?.data?.notices?.length || 0
      })
      
      let formattedNotices = []
      
      // 处理普通公告数据 - 直接取最新的3条
      if (noticesResponse.success && noticesResponse.data && noticesResponse.data.notices) {
        const notices = noticesResponse.data.notices
        
        // 直接取前3条最新的公告
        const topNotices = notices.slice(0, 3)
        
        formattedNotices = topNotices.map(notice => ({
          id: notice.id.toString(),
          title: notice.title,
          time: this.formatNoticeTime(notice.publishTime || notice.createTime),
          type: notice.type,
          isUrgent: notice.isUrgent,
          publisherName: notice.publisherName,
          dept: notice.dept
        }))
        
        console.log('格式化后的最新3条公告数据:', formattedNotices)
      }
      
      // 处理紧急通知数据 - 筛选标记为紧急的公告
      let formattedUrgentNotices = []
      if (noticesResponse.success && noticesResponse.data && noticesResponse.data.notices) {
        const allNotices = noticesResponse.data.notices
        
        // 筛选出标记为紧急的公告
        const urgentList = allNotices.filter(notice => {
          // 主要检查 isUrgent 字段（后端API已经转换为布尔值）
          return notice.isUrgent === true
        })
        
        console.log('筛选出的紧急公告数量:', urgentList.length)
        if (urgentList.length > 0) {
          console.log('紧急公告列表:', urgentList.map(n => ({ id: n.id, title: n.title, isUrgent: n.isUrgent })))
        } else {
          console.log('没有找到紧急公告，所有公告详情:')
          allNotices.forEach((notice, index) => {
            console.log(`公告${index + 1}:`, {
              id: notice.id,
              title: notice.title,
              isUrgent: notice.isUrgent,
              type: notice.type,
              status: notice.status
            })
          })
        }
        
        // 按发布时间倒序排列，确保最新的紧急公告在前
        urgentList.sort((a, b) => {
          const timeA = new Date(a.publishTime || a.publish_time || a.createTime || a.created_at)
          const timeB = new Date(b.publishTime || b.publish_time || b.createTime || b.created_at)
          return timeB - timeA
        })
        
        formattedUrgentNotices = urgentList.map(notice => ({
          id: notice.id.toString(),
          notice: notice.title,
          type: notice.type,
          publisherName: notice.publisherName || notice.publisher_name,
          dept: notice.dept || notice.publish_dept,
          publishTime: notice.publishTime || notice.publish_time,
          isUrgent: true // 确保标记为紧急
        }))
        
        console.log('筛选后的紧急通知数据:', formattedUrgentNotices)
        console.log('紧急通知数量:', formattedUrgentNotices.length)
      }
      
      // 更新页面数据
      const updateData = {}
      
      // 更新普通公告数据
      if (formattedNotices.length > 0) {
        updateData.notices = formattedNotices
        console.log('更新普通公告数据，共', formattedNotices.length, '条')
      } else {
        console.log('API返回的公告数据为空，保持原有数据')
      }
      
      // 更新紧急通知数据
      if (formattedUrgentNotices.length > 0) {
        updateData.urgentNotices = formattedUrgentNotices
        updateData.currentUrgentIndex = 0 // 重置轮播索引
        console.log('更新紧急通知数据，共', formattedUrgentNotices.length, '条')
      } else {
        // 如果没有紧急通知，清空数组
        updateData.urgentNotices = []
        updateData.currentUrgentIndex = 0
        console.log('没有找到紧急通知，清空紧急通知数据')
      }
      
      // 如果有数据更新，则更新页面
      if (Object.keys(updateData).length > 0) {
        this.setData(updateData)
        console.log('成功更新首页数据:', updateData)
      } else {
        console.log('没有数据需要更新，保持原有数据')
      }
      
    } catch (error) {
      console.error('加载最新公告数据失败:', error)
      // 网络错误或其他异常时，清空紧急通知数据，避免显示错误信息
      console.log('网络错误，清空紧急通知数据')
      this.setData({
        urgentNotices: [],
        currentUrgentIndex: 0
      })
      
      // 显示错误提示
      wx.showToast({
        title: '公告数据加载失败',
        icon: 'none',
        duration: 2000
      })
    }
  },

  // 格式化公告时间显示
  formatNoticeTime(timeString) {
    if (!timeString) return ''
    
    try {
      const date = new Date(timeString)
      const month = String(date.getMonth() + 1).padStart(2, '0')
      const day = String(date.getDate()).padStart(2, '0')
      return `${month}-${day}`
    } catch (error) {
      console.error('时间格式化失败:', error)
      return ''
    }
  },

  // 获取公告类型的中文显示文本
  getNoticeTypeText(type) {
    const typeMap = {
      'notice': '通知',
      'finance': '财务',
      'project': '项目',
      'policy': '政策',
      'activity': '活动',
      'urgent': '紧急'
    }
    return typeMap[type] || '公告'
  },

  // 格式化活动时间显示（更友好的格式）
  formatActivityTime(dateStr, timeStr) {
    if (!dateStr) return ''
    
    try {
      // 处理各种可能的日期时间格式
      let fullDateTime = dateStr
      
      // 如果有单独的时间字符串，组合日期和时间
      if (timeStr) {
        // 如果时间包含T和Z，说明是ISO格式，需要提取时间部分
        if (timeStr.includes('T')) {
          timeStr = timeStr.split('T')[1].split('.')[0] // 提取HH:MM:SS部分
        }
        
        // 如果日期包含T，说明是ISO格式，需要提取日期部分
        if (dateStr.includes('T')) {
          dateStr = dateStr.split('T')[0] // 提取YYYY-MM-DD部分
        }
        
        fullDateTime = `${dateStr} ${timeStr}`
      }
      
      // 解析日期时间
      const date = new Date(fullDateTime)
      if (isNaN(date.getTime())) return dateStr
      
      const year = date.getFullYear()
      const month = String(date.getMonth() + 1).padStart(2, '0')
      const day = String(date.getDate()).padStart(2, '0')
      const hours = String(date.getHours()).padStart(2, '0')
      const minutes = String(date.getMinutes()).padStart(2, '0')
      
      // 返回更友好的格式：YYYY年MM月DD日 HH:MM
      return `${year}年${month}月${day}日 ${hours}:${minutes}`
    } catch (error) {
      console.error('活动时间格式化错误:', error)
      return dateStr
    }
  },

  // 加载用户申请进度数据
  async loadUserProgress(forceRefresh = false) {
    try {
      console.log('开始加载用户申请进度数据', forceRefresh ? '(强制刷新)' : '')
      
      // 获取当前用户信息
      const currentUser = getCurrentUser()
      console.log('获取到的用户信息:', currentUser)
      if (!currentUser || !currentUser.userId) {
        console.log('用户未登录，清空进度数据')
        this.setData({
          progressList: []
        })
        return
      }
      
      console.log('当前用户ID:', currentUser.userId)
      
      // 调用API获取用户的最低生活保障申请列表
      console.log('开始调用API获取申请列表...')
      const progressParams = {
        page: 1,
        limit: 5 // 只获取最新的5条记录
        // 不传递status参数，获取所有状态的申请
      }
      
      // 如果是强制刷新，添加额外的时间戳参数
      if (forceRefresh) {
        progressParams._refresh = Date.now()
      }
      
      const response = await getMyApplications(currentUser.userId, progressParams)
      
      console.log('获取申请列表API响应:', response)
      console.log('API响应详情:', {
        success: response?.success,
        hasData: !!response?.data,
        hasApplications: !!response?.data?.applications,
        applicationsCount: response?.data?.applications?.length || 0
      })
      
      let formattedProgressList = []
      
      if (response.success && response.data && response.data.applications) {
        const applications = response.data.applications
        
        // 转换为首页需要的格式
        formattedProgressList = applications.map(app => ({
          id: app.id.toString(),
          title: app.title || '最低生活保障申请',
          statusTag: this.mapStatusToTag(app.status),
          statusText: this.mapStatusToText(app.status),
          updateTime: this.formatProgressTime(app.apply_time || app.updated_at),
          applicationNo: app.application_no,
          category: app.category || '民政社保',
          dept: app.dept || '民政办'
        }))
        
        console.log('格式化后的申请进度数据:', formattedProgressList)
      } else {
        console.log('API返回的申请数据为空，清空进度数据')
        // 清空数据，不使用默认数据
        formattedProgressList = []
      }
      
      // 更新页面数据
      this.setData({
        progressList: formattedProgressList
      })
      
      console.log('成功更新申请进度数据，共', formattedProgressList.length, '条')
      
    } catch (error) {
      console.error('加载用户申请进度数据失败:', error)
      // 网络错误或其他异常时，清空数据并显示错误提示
      console.log('清空进度数据，显示错误状态')
      this.setData({
        progressList: []
      })
      
      // 显示错误提示
      wx.showToast({
        title: '获取数据失败',
        icon: 'none',
        duration: 2000
      })
    }
  },

  // 加载活动轮播图数据
  async loadActiveActivities(forceRefresh = false) {
    try {
      console.log('开始加载活动轮播图数据', forceRefresh ? '(强制刷新)' : '')
      
      // 调用API获取即将开始或正在进行的活动
      const params = {
        page: 1,
        limit: 5 // 只获取最新的5个活动用于轮播
      }
      
      // 如果是强制刷新，添加额外的时间戳参数
      if (forceRefresh) {
        params._refresh = Date.now()
      }
      
      const response = await getActiveActivities(params)
      
      console.log('获取活动数据API响应:', response)
      console.log('活动数据详情:', {
        success: response?.success,
        hasData: !!response?.data,
        hasActivities: !!response?.data?.activities,
        activitiesCount: response?.data?.activities?.length || 0,
        firstActivity: response?.data?.activities?.[0] ? {
          id: response.data.activities[0].id,
          title: response.data.activities[0].title,
          background_color: response.data.activities[0].background_color
        } : null
      })
      
      let formattedBanners = []
      
      if (response.success && response.data && response.data.activities) {
        const activities = response.data.activities
        
        // 转换为轮播图需要的格式
        formattedBanners = activities.map((activity, index) => ({
          id: activity.id,
          theme: this.getActivityTheme(activity.title),
          title: activity.title,
          sub: activity.subtitle || '',
          icon: this.getActivityIcon(activity.title),
          action: 'activity',
          activityId: activity.id,
          description: activity.content ? activity.content.replace(/<[^>]*>/g, '').substring(0, 50) + '...' : '',
          startTime: this.formatActivityTime(activity.start_date, activity.start_time),
          endTime: this.formatActivityTime(activity.end_date, activity.end_time),
          status: activity.status,
          images: activity.images || [],
          participantCount: activity.participant_count || 0,
          maxParticipants: activity.max_participants || 0,
          location: activity.location || '',
          organizer: activity.organizer || '',
          backgroundColor: this.getStableBackgroundColor(activity.id, activity.background_color)
        }))
        
        console.log('格式化后的活动轮播图数据:', formattedBanners)
        console.log('第一个活动的背景色:', formattedBanners[0]?.backgroundColor)
      } else {
        console.log('API返回的活动数据为空，使用默认轮播图')
        // 如果API没有数据，使用默认的轮播图
        formattedBanners = [
          { 
            id: 1, 
            theme: 'spring', 
            title: '暂无活动', 
            sub: '敬请期待',
            icon: '🌱',
            action: 'activity',
            activityId: null,
            description: '暂无活动数据',
            startTime: '',
            endTime: '',
            status: 'upcoming',
            backgroundColor: this.getDefaultBackgroundColor()
          }
        ]
      }
      
      // 更新页面数据
      this.setData({
        banners: formattedBanners
      })
      
      console.log('成功更新活动轮播图数据，共', formattedBanners.length, '个')
      
    } catch (error) {
      console.error('加载活动轮播图数据失败:', error)
      // 网络错误或其他异常时，使用默认轮播图
      console.log('使用默认轮播图数据')
      this.setData({
        banners: [
          { 
            id: 1, 
            theme: 'spring', 
            title: '加载失败', 
            sub: '请检查网络连接',
            icon: '🌱',
            action: 'activity',
            activityId: null,
            description: '数据加载失败',
            startTime: '',
            endTime: '',
            status: 'upcoming',
            backgroundColor: this.getDefaultBackgroundColor()
          }
        ]
      })
      
      // 显示错误提示
      wx.showToast({
        title: '活动数据加载失败',
        icon: 'none',
        duration: 2000
      })
    }
  },

  // 测试背景色稳定性（调试用）
  testBackgroundColorStability() {
    console.log('=== 测试背景色稳定性 ===')
    const testActivities = [
      { id: 1, background_color: '#e8f5e8' },
      { id: 2, background_color: null },
      { id: 3, background_color: '' },
      { id: 4, background_color: '#e6f3ff' },
      { id: 5, background_color: undefined }
    ]
    
    testActivities.forEach(activity => {
      const bg1 = this.getStableBackgroundColor(activity.id, activity.background_color)
      const bg2 = this.getStableBackgroundColor(activity.id, activity.background_color)
      const bg3 = this.getStableBackgroundColor(activity.id, activity.background_color)
      
      console.log(`活动${activity.id}:`, {
        input: activity.background_color,
        bg1, bg2, bg3,
        isStable: bg1 === bg2 && bg2 === bg3
      })
    })
    console.log('=== 测试完成 ===')
  },
  getStableBackgroundColor(activityId, backgroundColor) {
    // 如果后台有背景色，优先使用
    if (backgroundColor && backgroundColor.trim()) {
      return this.convertHexToGradient(backgroundColor)
    }
    
    // 如果没有背景色，根据活动ID生成稳定的颜色
    const colors = [
      '#e8f5e8', // 淡绿色
      '#e6f3ff', // 淡蓝色
      '#fff2e6', // 淡橙色
      '#ffe6e6', // 淡红色
      '#f0e6ff', // 淡紫色
      '#e6ffe6', // 薄荷绿
      '#ffe6f0', // 淡粉色
      '#e6f0ff', // 天蓝色
      '#fff0e6', // 淡黄色
      '#f0ffe6', // 淡青绿
      '#f0f0ff', // 淡紫蓝
      '#ffe6ff'  // 淡紫红
    ]
    
    // 使用活动ID作为种子，确保相同ID总是返回相同颜色
    const colorIndex = activityId % colors.length
    const selectedColor = colors[colorIndex]
    const gradient = `linear-gradient(135deg, ${selectedColor} 0%, ${this.lightenColor(selectedColor, 20)} 100%)`
    
    console.log('为活动生成稳定背景色:', {
      activityId,
      backgroundColor,
      selectedColor,
      gradient
    })
    
    return gradient
  },
  convertHexToGradient(hexColor) {
    console.log('convertHexToGradient 输入:', hexColor, '类型:', typeof hexColor)
    
    if (!hexColor) {
      console.log('背景色为空，使用默认背景色')
      return this.getDefaultBackgroundColor()
    }
    
    // 如果是渐变字符串，直接返回
    if (hexColor.includes('linear-gradient')) {
      console.log('检测到渐变字符串，直接返回:', hexColor)
      return hexColor
    }
    
    // 如果是十六进制颜色，转换为渐变
    if (hexColor.startsWith('#')) {
      // 创建基于主色的渐变
      const gradient = `linear-gradient(135deg, ${hexColor} 0%, ${this.lightenColor(hexColor, 20)} 100%)`
      console.log('转换十六进制颜色为渐变:', hexColor, '->', gradient)
      return gradient
    }
    
    // 其他情况使用默认背景色
    console.log('未知颜色格式，使用默认背景色:', hexColor)
    return this.getDefaultBackgroundColor()
  },

  // 调整颜色亮度（用于创建渐变效果）
  lightenColor(hex, percent) {
    if (!hex.startsWith('#')) return hex
    
    // 移除#号
    const color = hex.slice(1)
    
    // 转换为RGB
    const r = parseInt(color.substr(0, 2), 16)
    const g = parseInt(color.substr(2, 2), 16)
    const b = parseInt(color.substr(4, 2), 16)
    
    // 增加亮度
    const newR = Math.min(255, Math.floor(r + (255 - r) * percent / 100))
    const newG = Math.min(255, Math.floor(g + (255 - g) * percent / 100))
    const newB = Math.min(255, Math.floor(b + (255 - b) * percent / 100))
    
    // 转换回十六进制
    const toHex = (n) => {
      const hex = n.toString(16)
      return hex.length === 1 ? '0' + hex : hex
    }
    
    return `#${toHex(newR)}${toHex(newG)}${toHex(newB)}`
  },

  // 获取默认背景色（当后台没有返回背景色时使用）
  getDefaultBackgroundColor() {
    // 使用一个固定的默认渐变色
    const defaultGradient = 'linear-gradient(135deg, #667eea 0%, #764ba2 100%)'
    console.log('使用默认背景色:', defaultGradient)
    return defaultGradient
  },

  // 根据活动标题获取主题样式
  getActivityTheme(title) {
    if (!title) return 'default'
    
    const titleLower = title.toLowerCase()
    if (titleLower.includes('春') || titleLower.includes('耕') || titleLower.includes('农')) {
      return 'spring'
    } else if (titleLower.includes('夏') || titleLower.includes('暑') || titleLower.includes('防')) {
      return 'summer'
    } else if (titleLower.includes('秋') || titleLower.includes('丰收') || titleLower.includes('收')) {
      return 'autumn'
    } else if (titleLower.includes('冬') || titleLower.includes('温暖') || titleLower.includes('过冬')) {
      return 'winter'
    } else if (titleLower.includes('文化') || titleLower.includes('传统') || titleLower.includes('技艺')) {
      return 'culture'
    } else {
      return 'default'
    }
  },

  // 根据活动标题获取图标
  getActivityIcon(title) {
    if (!title) return '🎯'
    
    const titleLower = title.toLowerCase()
    if (titleLower.includes('春') || titleLower.includes('耕') || titleLower.includes('农')) {
      return '🌱'
    } else if (titleLower.includes('夏') || titleLower.includes('暑') || titleLower.includes('防')) {
      return '☀️'
    } else if (titleLower.includes('秋') || titleLower.includes('丰收') || titleLower.includes('收')) {
      return '🌾'
    } else if (titleLower.includes('冬') || titleLower.includes('温暖') || titleLower.includes('过冬')) {
      return '❄️'
    } else if (titleLower.includes('文化') || titleLower.includes('传统') || titleLower.includes('技艺')) {
      return '🎭'
    } else {
      return '🎯'
    }
  },

  // 映射申请状态到标签样式
  mapStatusToTag(status) {
    const statusMap = {
      'pending': 'pending',      // 待审核 - 灰色
      'approved': 'approved',    // 已通过 - 绿色
      'rejected': 'rejected',    // 已驳回 - 红色
      'completed': 'done'        // 已完成 - 深绿色
    }
    return statusMap[status] || 'pending'
  },

  // 映射申请状态到显示文本
  mapStatusToText(status) {
    const statusMap = {
      'pending': '待审核',
      'approved': '已通过',
      'rejected': '已驳回', 
      'completed': '已完成'
    }
    return statusMap[status] || '待审核'
  },

  // 格式化进度时间显示
  formatProgressTime(timeString) {
    if (!timeString) return ''
    
    try {
      const date = new Date(timeString)
      const month = String(date.getMonth() + 1).padStart(2, '0')
      const day = String(date.getDate()).padStart(2, '0')
      const hour = String(date.getHours()).padStart(2, '0')
      const minute = String(date.getMinutes()).padStart(2, '0')
      return `${month}-${day} ${hour}:${minute}`
    } catch (error) {
      console.error('进度时间格式化失败:', error)
      return ''
    }
  },

  // 紧急通知点击事件
  onTapUrgent() {
    const urgentNotices = this.data.urgentNotices
    if (!urgentNotices || urgentNotices.length === 0) {
      wx.showToast({ title: '暂无紧急通知', icon: 'none' })
      return
    }
    
    const currentNotice = urgentNotices[this.data.currentUrgentIndex]
    if (currentNotice && currentNotice.id) {
      console.log('点击紧急通知:', currentNotice.id)
      wx.navigateTo({ 
        url: `/pages/village/notice-detail/index?id=${currentNotice.id}`,
        success: () => console.log('跳转成功'),
        fail: (err) => {
          console.error('跳转失败:', err)
          wx.showToast({ title: '页面加载失败', icon: 'none' })
        }
      })
    } else {
      wx.showToast({ title: '通知信息错误', icon: 'none' })
    }
  },

  // 紧急通知轮播变化监听 - 优化版本
  onUrgentSwiperChange(e) {
    const urgentNotices = this.data.urgentNotices
    if (!urgentNotices || urgentNotices.length === 0) {
      return
    }
    
    const current = e.detail.current
    // 确保索引在有效范围内
    if (current >= 0 && current < urgentNotices.length && this.data.currentUrgentIndex !== current) {
      this.setData({ currentUrgentIndex: current })
    }
  },

  // 搜索 - 优化版本
  onSearchInput(e) { 
    const value = e.detail.value
    this.setData({ searchQuery: value })
    
    // 清除之前的定时器
    if (this.searchTimer) {
      clearTimeout(this.searchTimer)
    }
    
    // 设置防抖，避免频繁触发
    this.searchTimer = setTimeout(() => {
      // 这里可以添加实时搜索逻辑
    }, 300)
  },
  
  onSearchConfirm() { this.onSearch() },
  
  onSearch() {
    const q = (this.data.searchQuery || '').trim()
    if (!q) {
      wx.showToast({ title: '请输入关键词', icon: 'none' })
      return
    }
    
    // 显示加载状态
    wx.showLoading({ title: '搜索中...' })
    
    // 调用API搜索公告
    this.searchNoticesFromAPI(q)
  },

  // 调用API搜索公告和服务事项
  async searchNoticesFromAPI(keyword) {
    try {
      console.log('开始搜索，关键词:', keyword)
      
      // 并行调用搜索服务事项和公告的API
      const [serviceResponse, noticeResponse] = await Promise.allSettled([
        this.searchServiceItemsFromAPI(keyword),
        this.searchNoticesFromAPIOnly(keyword)
      ])
      
      wx.hideLoading()
      
      let allResults = []
      let pagination = null
      let searchInfo = null
      
      // 处理服务事项搜索结果
      if (serviceResponse.status === 'fulfilled' && serviceResponse.value.success) {
        const serviceData = serviceResponse.value.data
        const formattedServices = serviceData.items.map(item => ({
          type: 'service',
          id: item.id,
          title: item.title,
          desc: item.desc,
          dept: item.dept,
          category: item.cateName,
          icon: '📋',
          online: item.online,
          appoint: item.appoint,
          relevanceScore: item.relevanceScore
        }))
        allResults = [...allResults, ...formattedServices]
        console.log('服务事项搜索结果:', formattedServices.length, '条')
      } else {
        console.error('服务事项搜索失败:', serviceResponse.reason)
      }
      
      // 处理公告搜索结果
      if (noticeResponse.status === 'fulfilled' && noticeResponse.value.success) {
        const noticeData = noticeResponse.value.data
        if (noticeData.notices) {
          const formattedNotices = noticeData.notices.map(notice => ({
            type: 'notice',
            id: notice.id.toString(),
            title: notice.title,
            desc: notice.publishTime ? this.formatNoticeTime(notice.publishTime) : '',
            dept: notice.dept || notice.publisherName,
            typeText: this.getNoticeTypeText(notice.type),
            icon: '📢',
            readCount: notice.readCount,
            isUrgent: notice.isUrgent,
            publishTime: notice.publishTime,
            publisherName: notice.publisherName
          }))
          allResults = [...allResults, ...formattedNotices]
          pagination = noticeData.pagination
          searchInfo = noticeData.searchInfo
          console.log('公告搜索结果:', formattedNotices.length, '条')
        }
      } else {
        console.error('公告搜索失败:', noticeResponse.reason)
      }
      
      // 如果没有任何搜索结果
      if (allResults.length === 0) {
        wx.showToast({ 
          title: '未找到相关内容', 
          icon: 'none' 
        })
        return
      }
      
      console.log('总搜索结果:', allResults.length, '条')
      
      // 将搜索结果存储到全局数据中
      getApp().globalData = getApp().globalData || {}
      getApp().globalData.searchResults = allResults
      getApp().globalData.searchQuery = keyword
      getApp().globalData.searchInfo = searchInfo
      getApp().globalData.pagination = pagination
      
      // 跳转到搜索结果页面
      wx.navigateTo({
        url: `/pages/common/search-results/index`,
        success: () => console.log('跳转到搜索结果页面成功'),
        fail: (err) => {
          console.error('跳转失败:', err)
          wx.showToast({ title: '页面跳转失败', icon: 'none' })
        }
      })
      
    } catch (error) {
      console.error('搜索API调用失败:', error)
            this.hideGlobalLoading();
      wx.hideLoading()
      
      wx.showToast({ 
        title: '网络请求失败，请重试', 
        icon: 'none' 
      })
    }
  },

  // 搜索服务事项API
  async searchServiceItemsFromAPI(keyword) {
    try {
      console.log('调用服务事项搜索API，关键词:', keyword)
      const response = await searchServiceItems(keyword, {
        page: 1,
        limit: 20
      })
      console.log('服务事项搜索API响应:', response)
      return response
    } catch (error) {
      console.error('服务事项搜索API调用失败:', error)
      throw error
    }
  },

  // 搜索公告API（仅公告）
  async searchNoticesFromAPIOnly(keyword) {
    try {
      console.log('调用公告搜索API，关键词:', keyword)
      const response = await searchNotices({
        keyword: keyword,
        page: 1,
        limit: 20,
        sortBy: 'publish_time',
        sortOrder: 'desc'
      })
      console.log('公告搜索API响应:', response)
      return response
    } catch (error) {
      console.error('公告搜索API调用失败:', error)
      throw error
    }
  },

  // 执行搜索逻辑 - 与搜索结果页面保持一致
  performSearch(query) {
    const results = []
    const lowerQuery = query.toLowerCase()
    
    // 服务事项数据源 - 与搜索结果页面保持一致
    const services = [
      { id: 'i1', name: '最低生活保障申请', desc: '困难群众最低生活保障资格申请与复核', dept: '民政办', category: '民政社保' },
      { id: 'i2', name: '临时救助', desc: '突发困难家庭临时救助申领', dept: '民政办', category: '民政社保' },
      { id: 'i3', name: '特困供养申请', desc: '分散供养、集中供养对象认定', dept: '民政办', category: '民政社保' },
      { id: 'i4', name: '残疾人两项补贴', desc: '困难残疾人生活补贴、重度护理补贴', dept: '残联联络员', category: '民政社保' },
      { id: 'i5', name: '养老补贴申请', desc: '老年人生活补贴申请办理', dept: '民政办', category: '民政社保' },
      { id: 'i6', name: '宅基地申请', desc: '宅基地资格审核与建设申请', dept: '村两委', category: '城乡建设' },
      { id: 'i7', name: '危房改造申请', desc: '农村危房改造对象认定与补助', dept: '村建专干', category: '城乡建设' },
      { id: 'i8', name: '房屋建筑施工备案', desc: '农房建设施工备案', dept: '村建专干', category: '城乡建设' },
      { id: 'i9', name: '用地规划咨询', desc: '宅基地、生产用地规划政策咨询', dept: '自然资源协管员', category: '城乡建设' },
      { id: 'i10', name: '耕地地力保护补贴', desc: '农户年度耕地保护补贴申领', dept: '农业服务站', category: '农业农村' },
      { id: 'i11', name: '农机购置补贴', desc: '购机补贴申请与资料初审', dept: '农业服务站', category: '农业农村' },
      { id: 'i12', name: '高标准农田申报', desc: '高标准农田建设项目意向申报', dept: '农业服务站', category: '农业农村' },
      { id: 'i13', name: '矛盾纠纷调解', desc: '群众纠纷调解受理与处理进度查询', dept: '综治办', category: '综合治理' },
      { id: 'i14', name: '治安事件反映', desc: '治安隐患/事件上报与流转', dept: '网格员', category: '综合治理' },
      { id: 'i15', name: '重点人员帮扶', desc: '帮扶对象联系与走访预约', dept: '综治办', category: '综合治理' },
      { id: 'i16', name: '新农合参保咨询', desc: '城乡居民医疗参保与变更咨询', dept: '卫健室', category: '教育卫健' },
      { id: 'i17', name: '计免接种预约', desc: '儿童免疫接种预约登记', dept: '卫健室', category: '教育卫健' },
      { id: 'i18', name: '学生资助申请', desc: '困难学生助学金申请', dept: '村教育协理员', category: '教育卫健' },
      { id: 'i19', name: '户籍办理', desc: '户口迁入/迁出申请办理', dept: '派出所', category: '证件办理' },
      { id: 'i20', name: '居住证明开具', desc: '常住人口居住证明出具', dept: '村委办公室', category: '证件办理' },
      { id: 'i21', name: '婚育证明', desc: '婚育情况证明开具', dept: '计生专干', category: '证件办理' },
      { id: 'i22', name: '困难证明', desc: '家庭经济困难证明开具', dept: '民政办', category: '证件办理' },
      { id: 'i23', name: '用水报修', desc: '村内自来水设施故障报修', dept: '水务协管', category: '公共服务' },
      { id: 'i24', name: '路灯报修', desc: '公共照明故障上报与处理', dept: '村建专干', category: '公共服务' },
      { id: 'i25', name: '环境卫生投诉', desc: '垃圾清运、卫生死角反馈', dept: '环卫协管', category: '公共服务' },
      { id: 'i26', name: '秸秆焚烧举报', desc: '发现露天焚烧立即上报', dept: '生态环保员', category: '生态环保' },
      { id: 'i27', name: '河湖巡查上报', desc: '巡河巡湖发现问题上报', dept: '河长办协管', category: '生态环保' },
      { id: 'i28', name: '散养家禽规范指导', desc: '散养家禽管理与整改指导预约', dept: '生态环保员', category: '生态环保' }
    ]
    
    // 公告数据源 - 与搜索结果页面保持一致
    const notices = [
      { 
        id: 'n1', 
        type: 'notice', 
        typeText: '通知', 
        title: '关于台风预警通知，做好防范准备', 
        time: '10-05', 
        dept: '村委会' 
      },
      { 
        id: 'n2', 
        type: 'notice', 
        typeText: '通知', 
        title: '国庆假期垃圾分类与值班安排', 
        time: '09-28', 
        dept: '村委会' 
      },
      { 
        id: 'f1', 
        type: 'finance', 
        typeText: '财务', 
        title: '2023年9月村财务收支情况公示', 
        time: '10-03', 
        dept: '财务室' 
      },
      { 
        id: 'p1', 
        type: 'project', 
        typeText: '项目', 
        title: '村道路修缮工程进度公示', 
        time: '09-25', 
        dept: '工程部' 
      },
      { 
        id: 'f2', 
        type: 'finance', 
        typeText: '财务', 
        title: '2023年第三季度村集体资产收益公示', 
        time: '10-01', 
        dept: '财务室' 
      },
      { 
        id: 'p2', 
        type: 'project', 
        typeText: '项目', 
        title: '村文化广场建设项目招标公告', 
        time: '09-20', 
        dept: '工程部' 
      }
    ]
    
    // 搜索服务事项
    services.forEach(service => {
      const nameMatch = service.name.toLowerCase().includes(lowerQuery)
      const descMatch = service.desc.toLowerCase().includes(lowerQuery)
      const deptMatch = service.dept.toLowerCase().includes(lowerQuery)
      const categoryMatch = service.category.toLowerCase().includes(lowerQuery)
      
      if (nameMatch || descMatch || deptMatch || categoryMatch) {
        console.log('首页找到匹配的服务事项:', service.name, '查询:', query)
        results.push({
          type: 'service',
          id: service.id,
          title: service.name,
          desc: service.desc,
          dept: service.dept,
          category: service.category,
          icon: '📋'
        })
      }
    })
    
    // 搜索公告
    notices.forEach(notice => {
      if (notice.title.toLowerCase().includes(lowerQuery) ||
          notice.dept.toLowerCase().includes(lowerQuery) ||
          notice.typeText.toLowerCase().includes(lowerQuery)) {
        results.push({
          type: 'notice',
          id: notice.id,
          title: notice.title,
          desc: notice.time,
          dept: notice.dept,
          typeText: notice.typeText,
          icon: '📢'
        })
      }
    })
    
    // 搜索紧急通知（使用动态获取的数据）
    const urgentNotices = this.data.urgentNotices || []
    urgentNotices.forEach(notice => {
      if (notice.notice && notice.notice.toLowerCase().includes(lowerQuery)) {
        results.push({
          type: 'urgent',
          id: notice.id,
          title: notice.notice,
          desc: '紧急通知',
          icon: '⚠️'
        })
      }
    })
    
    return results
  },

  onPullDownRefresh() {
    this.refreshData()
  },

  async refreshData() {
    if (this.data.loading) return
    this.setData({ loading: true })
    
    try {
      console.log('开始刷新首页数据...')
      
      // 强制重新加载最新公告和紧急通知数据
      await this.loadLatestNotices(true) // 传入true表示强制刷新
      
      // 强制重新加载用户申请进度数据
      await this.loadUserProgress(true) // 传入true表示强制刷新
      
      // 强制重新加载活动轮播图数据
      await this.loadActiveActivities(true) // 传入true表示强制刷新
      
      this.setData({ loading: false })
      
      wx.stopPullDownRefresh()
      console.log('首页数据刷新完成')
      
      // 显示刷新成功提示
      wx.showToast({
        title: '刷新成功',
        icon: 'success',
        duration: 1500
      })
      
    } catch (error) {
      console.error('刷新数据失败:', error)
      this.setData({ loading: false })
      wx.stopPullDownRefresh()
      wx.showToast({ 
        title: '刷新失败，请重试', 
        icon: 'none' 
      })
    }
  },

  onTapBanner(e) {
    const id = e.currentTarget.dataset.id
    const action = e.currentTarget.dataset.action
    const activityId = e.currentTarget.dataset.activityId
    const banner = this.data.banners.find(item => item.id == id)
    
    if (!banner) {
      wx.showToast({ title: '轮播图信息错误', icon: 'none' })
      return
    }
    
    console.log('点击活动轮播图:', banner.title, '活动ID:', activityId, '状态:', banner.status)
    
    // 根据不同的action执行不同的跳转逻辑
    switch (action) {
      case 'activity':
        this.handleActivityClick(banner, activityId)
        break
      case 'service':
        console.log('跳转到办事页面')
        wx.switchTab({ 
          url: '/pages/service/index/index',
          success: () => console.log('跳转成功'),
          fail: (err) => {
            console.error('跳转失败:', err)
            wx.showToast({ title: '页面跳转失败', icon: 'none' })
          }
        })
        break
      case 'progress':
        console.log('跳转到进度页面')
        wx.navigateTo({ 
          url: '/pages/user/progress/index',
          success: () => console.log('跳转成功'),
          fail: (err) => {
            console.error('跳转失败:', err)
            wx.showToast({ title: '页面跳转失败', icon: 'none' })
          }
        })
        break
      case 'notice':
        console.log('跳转到村务公开页面')
        wx.switchTab({ 
          url: '/pages/village/open/index',
          success: () => console.log('跳转成功'),
          fail: (err) => {
            console.error('跳转失败:', err)
            wx.showToast({ title: '页面跳转失败', icon: 'none' })
          }
        })
        break
      case 'smart':
        console.log('跳转到智慧乡村功能')
        wx.showModal({
          title: '智慧乡村',
          content: '智慧乡村功能正在开发中，敬请期待！',
          showCancel: false,
          confirmText: '知道了'
        })
        break
      default:
        console.log('未知的轮播图动作:', action)
        wx.showToast({ title: banner.title, icon: 'none' })
    }
  },

  // 处理活动点击事件
  handleActivityClick(banner, activityId) {
    console.log('跳转到活动详情页面:', activityId)
    
    // 检查活动ID是否有效
    if (!activityId) {
      wx.showToast({ 
        title: '活动信息不完整', 
        icon: 'none',
        duration: 2000
      })
      return
    }
    
    // 直接跳转到活动详情页面
    wx.navigateTo({
      url: `/pages/activity/detail/index?id=${activityId}`,
      success: () => {
        console.log('跳转到活动详情页面成功')
      },
      fail: (err) => {
        console.error('跳转到活动详情页面失败:', err)
        wx.showToast({ 
          title: '页面跳转失败', 
          icon: 'none',
          duration: 2000
        })
      }
    })
  },

  onTapShortcut(e) {
    const key = e.currentTarget.dataset.key
    console.log('点击快捷入口:', key)
    
    switch (key) {
      case 'service':
        console.log('跳转到办事页面')
        wx.switchTab({ 
          url: '/pages/service/index/index',
          success: () => console.log('跳转成功'),
          fail: (err) => console.error('跳转失败:', err)
        })
        break
      case 'complain':
        console.log('跳转到投诉建议页面')
        wx.navigateTo({ 
          url: '/pages/village/complaints/index',
          success: () => console.log('跳转成功'),
          fail: (err) => console.error('跳转失败:', err)
        })
        break
      case 'open':
        console.log('跳转到村务公开页面')
        wx.switchTab({ 
          url: '/pages/village/open/index',
          success: () => console.log('跳转成功'),
          fail: (err) => console.error('跳转失败:', err)
        })
        break
      case 'progress':
        console.log('跳转到进度页面')
        wx.navigateTo({ 
          url: '/pages/user/progress/index',
          success: () => console.log('跳转成功'),
          fail: (err) => console.error('跳转失败:', err)
        })
        break
      default:
        console.log('未知的快捷入口:', key)
        wx.showToast({ title: '功能开发中', icon: 'none' })
    }
  },

  onTapMoreServices() { wx.switchTab({ url: '/pages/service/index/index' }) },
  onTapService(e) { 
    const id = e.currentTarget.dataset.id
    console.log('点击常办事项:', id)
    
    // 根据事项ID跳转到对应的办事页面
    const serviceMap = {
      'hukou': '/pages/service/hukou-apply/index',      // 户籍办理
      'dibao': '/pages/service/civil-affairs/apply/index',            // 低保申请
      'yanglao': '/pages/service/pension-subsidy/index', // 养老补贴
      'zhuzhai': '/pages/service/homestead-approval/index' // 宅基地审批
    }
    
    const targetUrl = serviceMap[id]
    if (targetUrl) {
      wx.navigateTo({ 
        url: targetUrl,
        success: () => console.log('跳转成功'),
        fail: (err) => {
          console.error('跳转失败:', err)
          wx.showToast({ title: '页面开发中', icon: 'none' })
        }
      })
    } else {
      wx.showToast({ title: '功能开发中', icon: 'none' })
    }
  },
  onTapMoreNotices() { wx.switchTab({ url: '/pages/village/open/index' }) },
  onTapNotice(e) { 
    const id = e.currentTarget.dataset.id
    console.log('点击公告:', id)
    
    if (id) {
      wx.navigateTo({ 
        url: `/pages/village/notice-detail/index?id=${id}`,
        success: () => console.log('跳转成功'),
        fail: (err) => {
          console.error('跳转失败:', err)
          wx.showToast({ title: '页面加载失败', icon: 'none' })
        }
      })
    } else {
      wx.showToast({ title: '公告ID不存在', icon: 'none' })
    }
  },

  // 进度
  onTapAllProgress() { wx.navigateTo({ url: '/pages/user/progress/index' }) },
  onTapProgressItem(e) { 
    const id = e.currentTarget.dataset.id
    console.log('点击进度项:', id)
    
    if (!id) {
      wx.showToast({ title: '数据错误，请重试', icon: 'none' })
      return
    }
    
    // 获取当前用户信息
    const currentUser = getCurrentUser()
    if (!currentUser || !currentUser.userId) {
      wx.showToast({ title: '请先登录', icon: 'none' })
      return
    }
    
    // 跳转到最低生活保障申请详情页面
    wx.navigateTo({ 
      url: `/pages/user/progress/detail/index?id=${id}&userId=${currentUser.userId}`,
      success: () => console.log('跳转到申请详情页面成功'),
      fail: (err) => {
        console.error('跳转失败:', err)
        wx.showToast({ title: '页面跳转失败', icon: 'none' })
      }
    })
  },

  // CTA：一键诉求
  onTapComplainCTA() {
    // 与快捷入口的投诉建议一致，这里直接引导
    wx.showToast({ title: '进入投诉建议', icon: 'none' })
    // 如有投诉页面，可改为：wx.switchTab({ url: '/pages/user/mine/index' }) 或具体投诉页
  },

  // 管理员入口（保留方法，入口在“我的”页）
  goAdmin() {
    if (isAdmin()) {
      wx.navigateTo({ url: '/pages/admin/index/index' })
    } else {
      wx.navigateTo({ url: '/pages/auth/login/index' })
    }
  }
})
